/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.beanutils;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Date;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.io.Serializable;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* <p>DynaBean which automatically adds properties to the <code>DynaClass</code>
* and provides <i>Lazy List</i> and <i>Lazy Map</i> features.</p>
*
* <p>DynaBeans deal with three types of properties - <i>simple</i>, <i>indexed</i> and <i>mapped</i> and
* have the following <code>get()</code> and <code>set()</code> methods for
* each of these types:</p>
* <ul>
* <li><i>Simple</i> property methods - <code>get(name)</code> and
* <code>set(name, value)</code></li>
* <li><i>Indexed</i> property methods - <code>get(name, index)</code> and
* <code>set(name, index, value)</code></li>
* <li><i>Mapped</i> property methods - <code>get(name, key)</code> and
* <code>set(name, key, value)</code></li>
* </ul>
*
* <p><b><u>Getting Property Values</u></b></p>
* <p>Calling any of the <code>get()</code> methods, for a property which
* doesn't exist, returns <code>null</code> in this implementation.</p>
*
* <p><b><u>Setting Simple Properties</u></b></p>
* <p>The <code>LazyDynaBean</code> will automatically add a property to the <code>DynaClass</code>
* if it doesn't exist when the <code>set(name, value)</code> method is called.</p>
*
* <code>DynaBean myBean = new LazyDynaBean();</code></br>
* <code>myBean.set("myProperty", "myValue");</code></br>
*
* <p><b><u>Setting Indexed Properties</u></b></p>
* <p>If the property <b>doesn't</b> exist, the <code>LazyDynaBean</code> will automatically add
* a property with an <code>ArrayList</code> type to the <code>DynaClass</code> when
* the <code>set(name, index, value)</code> method is called.
* It will also instantiate a new <code>ArrayList</code> and automatically <i>grow</i>
* the <code>List</code> so that it is big enough to accomodate the index being set.
* <code>ArrayList</code> is the default indexed property that LazyDynaBean uses but
* this can be easily changed by overriding the <code>defaultIndexedProperty(name)</code>
* method.</p>
*
* <code>DynaBean myBean = new LazyDynaBean();</code></br>
* <code>myBean.set("myIndexedProperty", 0, "myValue1");</code></br>
* <code>myBean.set("myIndexedProperty", 1, "myValue2");</code></br>
*
* <p>If the indexed property <b>does</b> exist in the <code>DynaClass</code> but is set to
* <code>null</code> in the <code>LazyDynaBean</code>, then it will instantiate a
* new <code>List</code> or <code>Array</code> as specified by the property's type
* in the <code>DynaClass</code> and automatically <i>grow</i> the <code>List</code>
* or <code>Array</code> so that it is big enough to accomodate the index being set.</p>
*
* <code>DynaBean myBean = new LazyDynaBean();</code></br>
* <code>MutableDynaClass myClass = (MutableDynaClass)myBean.getDynaClass();</code></br>
* <code>myClass.add("myIndexedProperty", int[].class);</code></br>
* <code>myBean.set("myIndexedProperty", 0, new Integer(10));</code></br>
* <code>myBean.set("myIndexedProperty", 1, new Integer(20));</code></br>
*
* <p><b><u>Setting Mapped Properties</u></b></p>
* <p>If the property <b>doesn't</b> exist, the <code>LazyDynaBean</code> will automatically add
* a property with a <code>HashMap</code> type to the <code>DynaClass</code> and
* instantiate a new <code>HashMap</code> in the DynaBean when the
* <code>set(name, key, value)</code> method is called. <code>HashMap</code> is the default
* mapped property that LazyDynaBean uses but this can be easily changed by overriding
* the <code>defaultMappedProperty(name)</code> method.</p>
*
* <code>DynaBean myBean = new LazyDynaBean();</code></br>
* <code>myBean.set("myMappedProperty", "myKey", "myValue");</code></br>
*
* <p>If the mapped property <b>does</b> exist in the <code>DynaClass</code> but is set to
* <code>null</code> in the <code>LazyDynaBean</code>, then it will instantiate a
* new <code>Map</code> as specified by the property's type in the <code>DynaClass</code>.</p>
*
* <code>DynaBean myBean = new LazyDynaBean();</code></br>
* <code>MutableDynaClass myClass = (MutableDynaClass)myBean.getDynaClass();</code></br>
* <code>myClass.add("myMappedProperty", TreeMap.class);</code></br>
* <code>myBean.set("myMappedProperty", "myKey", "myValue");</code></br>
*
* <p><b><u><i>Restricted</i> DynaClass</u></b></p>
* <p><code>MutableDynaClass</code> have a facility to <i>restrict</i> the <code>DynaClass</code>
* so that its properties cannot be modified. If the <code>MutableDynaClass</code> is
* restricted then calling any of the <code>set()</code> methods for a property which
* doesn't exist will result in a <code>IllegalArgumentException</code> being thrown.</p>
*
* @see LazyDynaClass
* @author Niall Pemberton
*/
public class LazyDynaBean implements DynaBean, Serializable {
/**
* Commons Logging
*/
private transient Log logger = LogFactory.getLog(LazyDynaBean.class);
/** BigInteger Zero */
protected static final BigInteger BigInteger_ZERO = new BigInteger("0");
/** BigDecimal Zero */
protected static final BigDecimal BigDecimal_ZERO = new BigDecimal("0");
/** Character Space */
protected static final Character Character_SPACE = new Character(' ');
/** Byte Zero */
protected static final Byte Byte_ZERO = new Byte((byte)0);
/** Short Zero */
protected static final Short Short_ZERO = new Short((short)0);
/** Integer Zero */
protected static final Integer Integer_ZERO = new Integer(0);
/** Long Zero */
protected static final Long Long_ZERO = new Long(0);
/** Float Zero */
protected static final Float Float_ZERO = new Float((byte)0);
/** Double Zero */
protected static final Double Double_ZERO = new Double((byte)0);
/**
* The <code>MutableDynaClass</code> "base class" that this DynaBean
* is associated with.
*/
protected Map values;
/** Map decorator for this DynaBean */
private transient Map mapDecorator;
/**
* The <code>MutableDynaClass</code> "base class" that this DynaBean
* is associated with.
*/
protected MutableDynaClass dynaClass;
// ------------------- Constructors ----------------------------------
/**
* Construct a new <code>LazyDynaBean</code> with a <code>LazyDynaClass</code> instance.
*/
public LazyDynaBean() {
this(new LazyDynaClass());
}
/**
* Construct a new <code>LazyDynaBean</code> with a <code>LazyDynaClass</code> instance.
*
* @param name Name of this DynaBean class
*/
public LazyDynaBean(String name) {
this(new LazyDynaClass(name));
}
/**
* Construct a new <code>DynaBean</code> associated with the specified
* <code>DynaClass</code> instance - if its not a <code>MutableDynaClass</code>
* then a new <code>LazyDynaClass</code> is created and the properties copied.
*
* @param dynaClass The DynaClass we are associated with
*/
public LazyDynaBean(DynaClass dynaClass) {
values = newMap();
if (dynaClass instanceof MutableDynaClass) {
this.dynaClass = (MutableDynaClass)dynaClass;
} else {
this.dynaClass = new LazyDynaClass(dynaClass.getName(), dynaClass.getDynaProperties());
}
}
// ------------------- Public Methods ----------------------------------
/**
* Return a Map representation of this DynaBean.
* </p>
* This, for example, could be used in JSTL in the following way to access
* a DynaBean's <code>fooProperty</code>:
* <ul><li><code>${myDynaBean.<b>map</b>.fooProperty}</code></li></ul>
*
* @return a Map representation of this DynaBean
*/
public Map getMap() {
// cache the Map
if (mapDecorator == null) {
mapDecorator = new DynaBeanMapDecorator(this);
}
return mapDecorator;
}
/**
* <p>Return the size of an indexed or mapped property.</p>
*
* @param name Name of the property
* @return The indexed or mapped property size
* @exception IllegalArgumentException if no property name is specified
*/
public int size(String name) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
Object value = values.get(name);
if (value == null) {
return 0;
}
if (value instanceof Map) {
return ((Map)value).size();
}
if (value instanceof List) {
return ((List)value).size();
}
if ((value.getClass().isArray())) {
return Array.getLength(value);
}
return 0;
}
// ------------------- DynaBean Methods ----------------------------------
/**
* Does the specified mapped property contain a value for the specified
* key value?
*
* @param name Name of the property to check
* @param key Name of the key to check
* @return <code>true<code> if the mapped property contains a value for
* the specified key, otherwise <code>false</code>
*
* @exception IllegalArgumentException if no property name is specified
*/
public boolean contains(String name, String key) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
Object value = values.get(name);
if (value == null) {
return false;
}
if (value instanceof Map) {
return (((Map) value).containsKey(key));
}
return false;
}
/**
* <p>Return the value of a simple property with the specified name.</p>
*
* <p><strong>N.B.</strong> Returns <code>null</code> if there is no property
* of the specified name.</p>
*
* @param name Name of the property whose value is to be retrieved.
* @return The property's value
* @exception IllegalArgumentException if no property name is specified
*/
public Object get(String name) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
// Value found
Object value = values.get(name);
if (value != null) {
return value;
}
// Property doesn't exist
if (!isDynaProperty(name)) {
return null;
}
// Property doesn't exist
value = createProperty(name, dynaClass.getDynaProperty(name).getType());
if (value != null) {
set(name, value);
}
return value;
}
/**
* <p>Return the value of an indexed property with the specified name.</p>
*
* <p><strong>N.B.</strong> Returns <code>null</code> if there is no 'indexed'
* property of the specified name.</p>
*
* @param name Name of the property whose value is to be retrieved
* @param index Index of the value to be retrieved
* @return The indexed property's value
*
* @exception IllegalArgumentException if the specified property
* exists, but is not indexed
* @exception IndexOutOfBoundsException if the specified index
* is outside the range of the underlying property
*/
public Object get(String name, int index) {
// If its not a property, then create default indexed property
if (!isDynaProperty(name)) {
set(name, defaultIndexedProperty(name));
}
// Get the indexed property
Object indexedProperty = get(name);
// Check that the property is indexed
if (!dynaClass.getDynaProperty(name).isIndexed()) {
throw new IllegalArgumentException
("Non-indexed property for '" + name + "[" + index + "]' "
+ dynaClass.getDynaProperty(name).getName());
}
// Grow indexed property to appropriate size
indexedProperty = growIndexedProperty(name, indexedProperty, index);
// Return the indexed value
if (indexedProperty.getClass().isArray()) {
return Array.get(indexedProperty, index);
} else if (indexedProperty instanceof List) {
return ((List)indexedProperty).get(index);
} else {
throw new IllegalArgumentException
("Non-indexed property for '" + name + "[" + index + "]' "
+ indexedProperty.getClass().getName());
}
}
/**
* <p>Return the value of a mapped property with the specified name.</p>
*
* <p><strong>N.B.</strong> Returns <code>null</code> if there is no 'mapped'
* property of the specified name.</p>
*
* @param name Name of the property whose value is to be retrieved
* @param key Key of the value to be retrieved
* @return The mapped property's value
*
* @exception IllegalArgumentException if the specified property
* exists, but is not mapped
*/
public Object get(String name, String key) {
// If its not a property, then create default mapped property
if (!isDynaProperty(name)) {
set(name, defaultMappedProperty(name));
}
// Get the mapped property
Object mappedProperty = get(name);
// Check that the property is mapped
if (!dynaClass.getDynaProperty(name).isMapped()) {
throw new IllegalArgumentException
("Non-mapped property for '" + name + "(" + key + ")' "
+ dynaClass.getDynaProperty(name).getType().getName());
}
// Get the value from the Map
if (mappedProperty instanceof Map) {
return (((Map) mappedProperty).get(key));
} else {
throw new IllegalArgumentException
("Non-mapped property for '" + name + "(" + key + ")'"
+ mappedProperty.getClass().getName());
}
}
/**
* Return the <code>DynaClass</code> instance that describes the set of
* properties available for this DynaBean.
*
* @return The associated DynaClass
*/
public DynaClass getDynaClass() {
return dynaClass;
}
/**
* Remove any existing value for the specified key on the
* specified mapped property.
*
* @param name Name of the property for which a value is to
* be removed
* @param key Key of the value to be removed
*
* @exception IllegalArgumentException if there is no property
* of the specified name
*/
public void remove(String name, String key) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
Object value = values.get(name);
if (value == null) {
return;
}
if (value instanceof Map) {
((Map) value).remove(key);
} else {
throw new IllegalArgumentException
("Non-mapped property for '" + name + "(" + key + ")'"
+ value.getClass().getName());
}
}
/**
* Set the value of a simple property with the specified name.
*
* @param name Name of the property whose value is to be set
* @param value Value to which this property is to be set
*
* @exception IllegalArgumentException if this is not an existing property
* name for our DynaClass and the MutableDynaClass is restricted
* @exception ConversionException if the specified value cannot be
* converted to the type required for this property
* @exception NullPointerException if an attempt is made to set a
* primitive property to null
*/
public void set(String name, Object value) {
// If the property doesn't exist, then add it
if (!isDynaProperty(name)) {
if (dynaClass.isRestricted()) {
throw new IllegalArgumentException
("Invalid property name '" + name + "' (DynaClass is restricted)");
}
if (value == null) {
dynaClass.add(name);
} else {
dynaClass.add(name, value.getClass());
}
}
DynaProperty descriptor = dynaClass.getDynaProperty(name);
if (value == null) {
if (descriptor.getType().isPrimitive()) {
throw new NullPointerException
("Primitive value for '" + name + "'");
}
} else if (!isAssignable(descriptor.getType(), value.getClass())) {
throw new ConversionException
("Cannot assign value of type '" +
value.getClass().getName() +
"' to property '" + name + "' of type '" +
descriptor.getType().getName() + "'");
}
// Set the property's value
values.put(name, value);
}
/**
* Set the value of an indexed property with the specified name.
*
* @param name Name of the property whose value is to be set
* @param index Index of the property to be set
* @param value Value to which this property is to be set
*
* @exception ConversionException if the specified value cannot be
* converted to the type required for this property
* @exception IllegalArgumentException if there is no property
* of the specified name
* @exception IllegalArgumentException if the specified property
* exists, but is not indexed
* @exception IndexOutOfBoundsException if the specified index
* is outside the range of the underlying property
*/
public void set(String name, int index, Object value) {
// If its not a property, then create default indexed property
if (!isDynaProperty(name)) {
set(name, defaultIndexedProperty(name));
}
// Get the indexed property
Object indexedProperty = get(name);
// Check that the property is indexed
if (!dynaClass.getDynaProperty(name).isIndexed()) {
throw new IllegalArgumentException
("Non-indexed property for '" + name + "[" + index + "]'"
+ dynaClass.getDynaProperty(name).getType().getName());
}
// Grow indexed property to appropriate size
indexedProperty = growIndexedProperty(name, indexedProperty, index);
// Set the value in an array
if (indexedProperty.getClass().isArray()) {
Array.set(indexedProperty, index, value);
} else if (indexedProperty instanceof List) {
((List)indexedProperty).set(index, value);
} else {
throw new IllegalArgumentException
("Non-indexed property for '" + name + "[" + index + "]' "
+ indexedProperty.getClass().getName());
}
}
/**
* Set the value of a mapped property with the specified name.
*
* @param name Name of the property whose value is to be set
* @param key Key of the property to be set
* @param value Value to which this property is to be set
*
* @exception ConversionException if the specified value cannot be
* converted to the type required for this property
* @exception IllegalArgumentException if there is no property
* of the specified name
* @exception IllegalArgumentException if the specified property
* exists, but is not mapped
*/
public void set(String name, String key, Object value) {
// If the 'mapped' property doesn't exist, then add it
if (!isDynaProperty(name)) {
set(name, defaultMappedProperty(name));
}
// Get the mapped property
Object mappedProperty = get(name);
// Check that the property is mapped
if (!dynaClass.getDynaProperty(name).isMapped()) {
throw new IllegalArgumentException
("Non-mapped property for '" + name + "(" + key + ")'"
+ dynaClass.getDynaProperty(name).getType().getName());
}
// Set the value in the Map
((Map)mappedProperty).put(key, value);
}
// ------------------- protected Methods ----------------------------------
/**
* Grow the size of an indexed property
* @param name The name of the property
* @param indexedProperty The current property value
* @param index The indexed value to grow the property to (i.e. one less than
* the required size)
* @return The new property value (grown to the appropriate size)
*/
protected Object growIndexedProperty(String name, Object indexedProperty, int index) {
// Grow a List to the appropriate size
if (indexedProperty instanceof List) {
List list = (List)indexedProperty;
while (index >= list.size()) {
Class contentType = getDynaClass().getDynaProperty(name).getContentType();
Object value = null;
if (contentType != null) {
value = createProperty(name+"["+list.size()+"]", contentType);
}
list.add(value);
}
}
// Grow an Array to the appropriate size
if ((indexedProperty.getClass().isArray())) {
int length = Array.getLength(indexedProperty);
if (index >= length) {
Class componentType = indexedProperty.getClass().getComponentType();
Object newArray = Array.newInstance(componentType, (index + 1));
System.arraycopy(indexedProperty, 0, newArray, 0, length);
indexedProperty = newArray;
set(name, indexedProperty);
int newLength = Array.getLength(indexedProperty);
for (int i = length; i < newLength; i++) {
Array.set(indexedProperty, i, createProperty(name+"["+i+"]", componentType));
}
}
}
return indexedProperty;
}
/**
* Create a new Instance of a Property
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createProperty(String name, Class type) {
if (type == null) {
return null;
}
// Create Lists, arrays or DynaBeans
if (type.isArray() || List.class.isAssignableFrom(type)) {
return createIndexedProperty(name, type);
}
if (Map.class.isAssignableFrom(type)) {
return createMappedProperty(name, type);
}
if (DynaBean.class.isAssignableFrom(type)) {
return createDynaBeanProperty(name, type);
}
if (type.isPrimitive()) {
return createPrimitiveProperty(name, type);
}
if (Number.class.isAssignableFrom(type)) {
return createNumberProperty(name, type);
}
return createOtherProperty(name, type);
}
/**
* Create a new Instance of an 'Indexed' Property
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createIndexedProperty(String name, Class type) {
// Create the indexed object
Object indexedProperty = null;
if (type == null) {
indexedProperty = defaultIndexedProperty(name);
} else if (type.isArray()) {
indexedProperty = Array.newInstance(type.getComponentType(), 0);
} else if (List.class.isAssignableFrom(type)) {
if (type.isInterface()) {
indexedProperty = defaultIndexedProperty(name);
} else {
try {
indexedProperty = type.newInstance();
}
catch (Exception ex) {
throw new IllegalArgumentException
("Error instantiating indexed property of type '" +
type.getName() + "' for '" + name + "' " + ex);
}
}
} else {
throw new IllegalArgumentException
("Non-indexed property of type '" + type.getName() + "' for '" + name + "'");
}
return indexedProperty;
}
/**
* Create a new Instance of a 'Mapped' Property
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createMappedProperty(String name, Class type) {
// Create the mapped object
Object mappedProperty = null;
if (type == null) {
mappedProperty = defaultMappedProperty(name);
} else if (type.isInterface()) {
mappedProperty = defaultMappedProperty(name);
} else if (Map.class.isAssignableFrom(type)) {
try {
mappedProperty = type.newInstance();
}
catch (Exception ex) {
throw new IllegalArgumentException
("Error instantiating mapped property of type '" +
type.getName() + "' for '" + name + "' " + ex);
}
} else {
throw new IllegalArgumentException
("Non-mapped property of type '" + type.getName() + "' for '" + name + "'");
}
return mappedProperty;
}
/**
* Create a new Instance of a 'DynaBean' Property.
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createDynaBeanProperty(String name, Class type) {
try {
return type.newInstance();
}
catch (Exception ex) {
if (logger().isWarnEnabled()) {
logger().warn("Error instantiating DynaBean property of type '" +
type.getName() + "' for '" + name + "' " + ex);
}
return null;
}
}
/**
* Create a new Instance of a 'Primitive' Property.
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createPrimitiveProperty(String name, Class type) {
if (type == Boolean.TYPE) {
return Boolean.FALSE;
} else if (type == Integer.TYPE) {
return Integer_ZERO;
} else if (type == Long.TYPE) {
return Long_ZERO;
} else if (type == Double.TYPE) {
return Double_ZERO;
} else if (type == Float.TYPE) {
return Float_ZERO;
} else if (type == Byte.TYPE) {
return Byte_ZERO;
} else if (type == Short.TYPE) {
return Short_ZERO;
} else if (type == Character.TYPE) {
return Character_SPACE;
} else {
return null;
}
}
/**
* Create a new Instance of a <code>java.lang.Number</code> Property.
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createNumberProperty(String name, Class type) {
return null;
}
/**
* Create a new Instance of other Property types
* @param name The name of the property
* @param type The class of the property
* @return The new value
*/
protected Object createOtherProperty(String name, Class type) {
if (type == Object.class ||
type == String.class ||
type == Boolean.class ||
type == Character.class ||
Date.class.isAssignableFrom(type)) {
return null;
}
try {
return type.newInstance();
}
catch (Exception ex) {
if (logger().isWarnEnabled()) {
logger().warn("Error instantiating property of type '" + type.getName() + "' for '" + name + "' " + ex);
}
return null;
}
}
/**
* <p>Creates a new <code>ArrayList</code> for an 'indexed' property
* which doesn't exist.</p>
*
* <p>This method shouls be overriden if an alternative <code>List</code>
* or <code>Array</code> implementation is required for 'indexed' properties.</p>
*
* @param name Name of the 'indexed property.
* @return The default value for an indexed property (java.util.ArrayList)
*/
protected Object defaultIndexedProperty(String name) {
return new ArrayList();
}
/**
* <p>Creates a new <code>HashMap</code> for a 'mapped' property
* which doesn't exist.</p>
*
* <p>This method can be overriden if an alternative <code>Map</code>
* implementation is required for 'mapped' properties.</p>
*
* @param name Name of the 'mapped property.
* @return The default value for a mapped property (java.util.HashMap)
*/
protected Map defaultMappedProperty(String name) {
return new HashMap();
}
/**
* Indicates if there is a property with the specified name.
* @param name The name of the property to check
* @return <code>true<code> if there is a property of the
* specified name, otherwise <code>false</code>
*/
protected boolean isDynaProperty(String name) {
if (name == null) {
throw new IllegalArgumentException("No property name specified");
}
// Handle LazyDynaClasses
if (dynaClass instanceof LazyDynaClass) {
return ((LazyDynaClass)dynaClass).isDynaProperty(name);
}
// Handle other MutableDynaClass
return dynaClass.getDynaProperty(name) == null ? false : true;
}
/**
* Is an object of the source class assignable to the destination class?
*
* @param dest Destination class
* @param source Source class
* @return <code>true<code> if the source class is assignable to the
* destination class, otherwise <code>false</code>
*/
protected boolean isAssignable(Class dest, Class source) {
if (dest.isAssignableFrom(source) ||
((dest == Boolean.TYPE) && (source == Boolean.class)) ||
((dest == Byte.TYPE) && (source == Byte.class)) ||
((dest == Character.TYPE) && (source == Character.class)) ||
((dest == Double.TYPE) && (source == Double.class)) ||
((dest == Float.TYPE) && (source == Float.class)) ||
((dest == Integer.TYPE) && (source == Integer.class)) ||
((dest == Long.TYPE) && (source == Long.class)) ||
((dest == Short.TYPE) && (source == Short.class))) {
return (true);
} else {
return (false);
}
}
/**
* <p>Creates a new instance of the <code>Map</code>.</p>
* @return a new Map instance
*/
protected Map newMap() {
return new HashMap();
}
/**
* <p>Returns the <code>Log</code>.
*/
private Log logger() {
if (logger == null) {
logger = LogFactory.getLog(LazyDynaBean.class);
}
return logger;
}
}